home *** CD-ROM | disk | FTP | other *** search
/ Champak 123 / (Vol 123) Jan 13 2011.iso / Games / Rings.swf / scripts / __Packages / mx / transitions / easing / Regular.as next >
Text File  |  2011-01-13  |  34KB  |  726 lines
  1. var ┬º\x01┬º = 234;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 234)
  6.    {
  7.       set("\x01",eval("\x01") + 218);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.       continue;
  11.    }
  12.    if(eval("\x01") != 290)
  13.    {
  14.       if(eval("\x01") == 724)
  15.       {
  16.          set("\x01",eval("\x01") - 593);
  17.          toggleHighQuality();
  18.          toggleHighQuality();
  19.          if(!┬º┬ºpop()[┬º┬ºpop()])
  20.          {
  21.             eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(9)][┬º┬ºconstant(10)](_loc4_);
  22.             var _loc3_ = _loc1_[┬º┬ºconstant(11)](┬º┬ºconstant(8),9876);
  23.             _loc3_[┬º┬ºconstant(12)] = function()
  24.             {
  25.                _global[┬º┬ºconstant(7)][┬º┬ºconstant(13)](┬º┬ºconstant(12));
  26.             };
  27.          }
  28.          ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  29.          _loc1_[┬º┬ºconstant(14)] = ┬º┬ºconstant(15);
  30.          ┬º┬ºconstant(16)(eval(┬º┬ºconstant(1))[┬º┬ºconstant(3)][┬º┬ºconstant(4)][┬º┬ºconstant(5)],null,1);
  31.          break;
  32.       }
  33.       if(eval("\x01") == 28)
  34.       {
  35.          set("\x01",eval("\x01") + 851);
  36.          ┬º┬ºpush(true);
  37.          continue;
  38.          continue;
  39.       }
  40.       if(eval("\x01") != 172)
  41.       {
  42.          if(eval("\x01") == 131)
  43.          {
  44.             set("\x01",eval("\x01") + 804);
  45.             if(!_global.mx)
  46.             {
  47.                _global.mx = new Object();
  48.             }
  49.             ┬º┬ºpop();
  50.             if(!_global.mx.transitions)
  51.             {
  52.                _global.mx.transitions = new Object();
  53.             }
  54.             ┬º┬ºpop();
  55.             if(!_global.mx.transitions.easing)
  56.             {
  57.                _global.mx.transitions.easing = new Object();
  58.             }
  59.             ┬º┬ºpop();
  60.             if(!_global.mx.transitions.easing.Regular)
  61.             {
  62.                var _loc2_ = mx.transitions.easing.Regular = function()
  63.                {
  64.                }.prototype;
  65.                mx.transitions.easing.Regular = function()
  66.                {
  67.                }.easeIn = function(t, b, c, d)
  68.                {
  69.                   return c * (t /= d) * t + b;
  70.                };
  71.                mx.transitions.easing.Regular = function()
  72.                {
  73.                }.easeOut = function(t, b, c, d)
  74.                {
  75.                   return (- c) * (t /= d) * (t - 2) + b;
  76.                };
  77.                mx.transitions.easing.Regular = function()
  78.                {
  79.                }.easeInOut = function(t, b, c, d)
  80.                {
  81.                   if((t /= d / 2) < 1)
  82.                   {
  83.                      return c / 2 * t * t + b;
  84.                   }
  85.                   return (- c) / 2 * ((t = t - 1) * (t - 2) - 1) + b;
  86.                };
  87.                mx.transitions.easing.Regular = function()
  88.                {
  89.                }.version = "1.1.0.52";
  90.                ┬º┬ºpush(ASSetPropFlags(mx.transitions.easing.Regular.prototype,null,1));
  91.             }
  92.             ┬º┬ºpop();
  93.             break;
  94.          }
  95.          if(eval("\x01") != 942)
  96.          {
  97.             if(eval("\x01") != 115)
  98.             {
  99.                if(eval("\x01") == 343)
  100.                {
  101.                   set("\x01",eval("\x01") + 20);
  102.                   break;
  103.                }
  104.                if(eval("\x01") != 29)
  105.                {
  106.                   if(eval("\x01") != 326)
  107.                   {
  108.                      if(eval("\x01") == 935)
  109.                      {
  110.                         set("\x01",eval("\x01") - 935);
  111.                         break;
  112.                      }
  113.                      if(eval("\x01") == 363)
  114.                      {
  115.                         set("\x01",eval("\x01") - 191);
  116.                         ┬º┬ºpush(true);
  117.                         continue;
  118.                         continue;
  119.                      }
  120.                      if(eval("\x01") != 743)
  121.                      {
  122.                         if(eval("\x01") != 452)
  123.                         {
  124.                            if(eval("\x01") == 387)
  125.                            {
  126.                               set("\x01",eval("\x01") - 359);
  127.                               break;
  128.                            }
  129.                            if(eval("\x01") != 879)
  130.                            {
  131.                               if(eval("\x01") == 281)
  132.                               {
  133.                                  set("\x01",eval("\x01") + 661);
  134.                                  loop1:
  135.                                  while(true)
  136.                                  {
  137.                                     set(┬º┬ºpop(),┬º┬ºpop() + ┬º┬ºpop());
  138.                                     ┬º┬ºpush(true);
  139.                                     while(true)
  140.                                     {
  141.                                        if(eval("\x01") == 160)
  142.                                        {
  143.                                           set("\x01",eval("\x01") + 766);
  144.                                           ┬º┬ºpush(true);
  145.                                           continue;
  146.                                        }
  147.                                        if(eval("\x01") == 717)
  148.                                        {
  149.                                           set("\x01",eval("\x01") - 564);
  150.                                           ┬º┬ºpush(true);
  151.                                           continue;
  152.                                        }
  153.                                        if(eval("\x01") == 771)
  154.                                        {
  155.                                           set("\x01",eval("\x01") - 292);
  156.                                           break loop0;
  157.                                        }
  158.                                        if(eval("\x01") == 755)
  159.                                        {
  160.                                           set("\x01",eval("\x01") - 126);
  161.                                           break loop0;
  162.                                        }
  163.                                        if(eval("\x01") == 795)
  164.                                        {
  165.                                           set("\x01",eval("\x01") - 294);
  166.                                           ┬º┬ºpush(true);
  167.                                           continue;
  168.                                        }
  169.                                        if(eval("\x01") == 153)
  170.                                        {
  171.                                           set("\x01",eval("\x01") + 763);
  172.                                           if(┬º┬ºpop())
  173.                                           {
  174.                                              set("\x01",eval("\x01") - 121);
  175.                                           }
  176.                                           continue;
  177.                                        }
  178.                                        if(eval("\x01") == 715)
  179.                                        {
  180.                                           set("\x01",eval("\x01") - 221);
  181.                                           if(!_global.RingCell)
  182.                                           {
  183.                                              _global.RingCell extends MovieClip;
  184.                                              _loc2_ = _global.RingCell = function()
  185.                                              {
  186.                                                 super();
  187.                                                 this.hasType = new Array(false,false,false,false);
  188.                                              }.prototype;
  189.                                              _loc2_.GetHighestRingType = function()
  190.                                              {
  191.                                                 var _loc3_ = 0;
  192.                                                 var _loc2_ = 1;
  193.                                                 while(_loc2_ < 5)
  194.                                                 {
  195.                                                    if(this.hasType[_loc2_ - 1] == true)
  196.                                                    {
  197.                                                       _loc3_ = _loc2_;
  198.                                                    }
  199.                                                    _loc2_ = _loc2_ + 1;
  200.                                                 }
  201.                                                 return _loc3_;
  202.                                              };
  203.                                              _loc2_.GetLowestRingType = function()
  204.                                              {
  205.                                                 var _loc3_ = 5;
  206.                                                 var _loc2_ = 4;
  207.                                                 while(_loc2_ > 0)
  208.                                                 {
  209.                                                    if(this.hasType[_loc2_ - 1] == true)
  210.                                                    {
  211.                                                       _loc3_ = _loc2_;
  212.                                                    }
  213.                                                    _loc2_ = _loc2_ - 1;
  214.                                                 }
  215.                                                 return _loc3_;
  216.                                              };
  217.                                              _loc2_.CheckCompleteRing = function()
  218.                                              {
  219.                                                 var _loc2_ = 0;
  220.                                                 if(this.hasType[3] == true)
  221.                                                 {
  222.                                                    if(this.hasType[2] == true)
  223.                                                    {
  224.                                                       _loc2_ = 3;
  225.                                                       if(this.hasType[1] == true)
  226.                                                       {
  227.                                                          _loc2_ = 2;
  228.                                                          if(this.hasType[0] == true)
  229.                                                          {
  230.                                                             _loc2_ = 1;
  231.                                                          }
  232.                                                       }
  233.                                                    }
  234.                                                 }
  235.                                                 return _loc2_;
  236.                                              };
  237.                                              ┬º┬ºpush(ASSetPropFlags(_global.RingCell.prototype,null,1));
  238.                                           }
  239.                                           ┬º┬ºpop();
  240.                                           break loop0;
  241.                                        }
  242.                                        if(eval("\x01") == 501)
  243.                                        {
  244.                                           set("\x01",eval("\x01") + 227);
  245.                                           if(┬º┬ºpop())
  246.                                           {
  247.                                              set("\x01",eval("\x01") - 267);
  248.                                           }
  249.                                           continue;
  250.                                        }
  251.                                        if(eval("\x01") == 818)
  252.                                        {
  253.                                           set("\x01",eval("\x01") - 148);
  254.                                           if(┬º┬ºpop())
  255.                                           {
  256.                                              set("\x01",eval("\x01") + 47);
  257.                                           }
  258.                                           continue;
  259.                                        }
  260.                                        if(eval("\x01") == 728)
  261.                                        {
  262.                                           set("\x01",eval("\x01") - 267);
  263.                                           break loop0;
  264.                                        }
  265.                                        if(eval("\x01") == 916)
  266.                                        {
  267.                                           break loop1;
  268.                                        }
  269.                                        if(eval("\x01") == 461)
  270.                                        {
  271.                                           set("\x01",eval("\x01") + 348);
  272.                                           ┬º┬ºpush(true);
  273.                                           continue;
  274.                                        }
  275.                                        if(eval("\x01") == 809)
  276.                                        {
  277.                                           set("\x01",eval("\x01") - 54);
  278.                                           if(┬º┬ºpop())
  279.                                           {
  280.                                              set("\x01",eval("\x01") - 126);
  281.                                           }
  282.                                           continue;
  283.                                        }
  284.                                        if(eval("\x01") == 629)
  285.                                        {
  286.                                           break;
  287.                                        }
  288.                                        if(eval("\x01") == 670)
  289.                                        {
  290.                                           set("\x01",eval("\x01") + 47);
  291.                                           break loop0;
  292.                                        }
  293.                                        if(eval("\x01") == 632)
  294.                                        {
  295.                                           set("\x01",eval("\x01") + 14);
  296.                                           if(┬º┬ºpop())
  297.                                           {
  298.                                              set("\x01",eval("\x01") - 561);
  299.                                           }
  300.                                           continue;
  301.                                        }
  302.                                        if(eval("\x01") != 646)
  303.                                        {
  304.                                           if(eval("\x01") != 85)
  305.                                           {
  306.                                              if(eval("\x01") == 479)
  307.                                              {
  308.                                                 set("\x01",eval("\x01") + 339);
  309.                                                 ┬º┬ºpush(true);
  310.                                                 continue;
  311.                                              }
  312.                                              if(eval("\x01") != 926)
  313.                                              {
  314.                                                 if(eval("\x01") != 299)
  315.                                                 {
  316.                                                    if(eval("\x01") == 505)
  317.                                                    {
  318.                                                       set("\x01",eval("\x01") + 210);
  319.                                                       break loop0;
  320.                                                    }
  321.                                                    if(eval("\x01") == 494)
  322.                                                    {
  323.                                                       set("\x01",eval("\x01") - 494);
  324.                                                       break loop0;
  325.                                                    }
  326.                                                 }
  327.                                                 set("\x01",eval("\x01") + 206);
  328.                                                 if(┬º┬ºpop())
  329.                                                 {
  330.                                                    set("\x01",eval("\x01") + 210);
  331.                                                 }
  332.                                              }
  333.                                              set("\x01",eval("\x01") - 155);
  334.                                              if(┬º┬ºpop())
  335.                                              {
  336.                                                 set("\x01",eval("\x01") - 292);
  337.                                              }
  338.                                           }
  339.                                           set("\x01",eval("\x01") + 214);
  340.                                           ┬º┬ºpush(true);
  341.                                           continue;
  342.                                           continue;
  343.                                           continue;
  344.                                           break loop0;
  345.                                        }
  346.                                        set("\x01",eval("\x01") - 561);
  347.                                        ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop() + ┬º┬ºpop()[┬º┬ºpop()]();
  348.                                        if(eval(┬º┬ºconstant(18))[┬º┬ºconstant(19)](_global.RingCell = function()
  349.                                        {
  350.                                           super();
  351.                                           this.hasType = new Array(false,false,false,false);
  352.                                        }[┬º┬ºconstant(17)] - _global.RingCell = function()
  353.                                        {
  354.                                           super();
  355.                                           this.hasType = new Array(false,false,false,false);
  356.                                        }.hasType) < _global.RingCell = function()
  357.                                        {
  358.                                           super();
  359.                                           this.hasType = new Array(false,false,false,false);
  360.                                        }.Array * 2)
  361.                                        {
  362.                                           ┬º┬ºgoto(addr21);
  363.                                        }
  364.                                     }
  365.                                  }
  366.                                  set("\x01",eval("\x01") - 121);
  367.                                  break;
  368.                               }
  369.                               if(eval("\x01") == 627)
  370.                               {
  371.                                  set("\x01",eval("\x01") - 305);
  372.                                  ┬º┬ºpush(true);
  373.                                  continue;
  374.                               }
  375.                               if(eval("\x01") == 151)
  376.                               {
  377.                                  set("\x01",eval("\x01") + 130);
  378.                                  if(┬º┬ºpop())
  379.                                  {
  380.                                     set("\x01",eval("\x01") + 661);
  381.                                  }
  382.                                  continue;
  383.                               }
  384.                               if(eval("\x01") == 55)
  385.                               {
  386.                                  set("\x01",eval("\x01") + 688);
  387.                                  ┬º┬ºpush(true);
  388.                                  continue;
  389.                               }
  390.                               if(eval("\x01") != 322)
  391.                               {
  392.                                  if(eval("\x01") == 352)
  393.                                  {
  394.                                     set("\x01",eval("\x01") - 62);
  395.                                     nextFrame();
  396.                                     break;
  397.                                  }
  398.                                  if(eval("\x01") != 321)
  399.                                  {
  400.                                     if(eval("\x01") == 676)
  401.                                     {
  402.                                        set("\x01",eval("\x01") - 621);
  403.                                        break;
  404.                                     }
  405.                                     if(eval("\x01") == 418)
  406.                                     {
  407.                                        set("\x01",eval("\x01") + 209);
  408.                                        break;
  409.                                     }
  410.                                  }
  411.                                  set("\x01",eval("\x01") - 170);
  412.                                  ┬º┬ºpush(true);
  413.                               }
  414.                               set("\x01",eval("\x01") + 402);
  415.                            }
  416.                            set("\x01",eval("\x01") - 203);
  417.                            if(┬º┬ºpop())
  418.                            {
  419.                               set("\x01",eval("\x01") - 621);
  420.                            }
  421.                            continue;
  422.                         }
  423.                         set("\x01",eval("\x01") - 100);
  424.                         if(┬º┬ºpop())
  425.                         {
  426.                            set("\x01",eval("\x01") - 62);
  427.                         }
  428.                         continue;
  429.                         if(┬º┬ºpop())
  430.                         {
  431.                            set("\x01",eval("\x01") - 593);
  432.                         }
  433.                      }
  434.                      set("\x01",eval("\x01") - 325);
  435.                      if(┬º┬ºpop())
  436.                      {
  437.                         set("\x01",eval("\x01") + 209);
  438.                      }
  439.                   }
  440.                   set("\x01",eval("\x01") + 17);
  441.                   if(┬º┬ºpop())
  442.                   {
  443.                      set("\x01",eval("\x01") + 20);
  444.                   }
  445.                   continue;
  446.                }
  447.                set("\x01",eval("\x01") + 358);
  448.                if(┬º┬ºpop())
  449.                {
  450.                   set("\x01",eval("\x01") - 359);
  451.                }
  452.                continue;
  453.                continue;
  454.                continue;
  455.                break;
  456.             }
  457.             set("\x01",eval("\x01") + 206);
  458.             loop3:
  459.             while(true)
  460.             {
  461.                set("\x01",eval("\x01") + 293);
  462.                loop4:
  463.                while(true)
  464.                {
  465.                   while(true)
  466.                   {
  467.                      if(eval("\x01") == 79)
  468.                      {
  469.                         set("\x01",eval("\x01") + 735);
  470.                         ┬º┬ºpush(true);
  471.                         continue;
  472.                      }
  473.                      if(eval("\x01") == 688)
  474.                      {
  475.                         break;
  476.                      }
  477.                      if(eval("\x01") == 310)
  478.                      {
  479.                         set("\x01",eval("\x01") - 67);
  480.                         ┬º┬ºpush(true);
  481.                         continue;
  482.                      }
  483.                      if(eval("\x01") == 334)
  484.                      {
  485.                         set("\x01",eval("\x01") - 24);
  486.                         break loop0;
  487.                      }
  488.                      if(eval("\x01") == 595)
  489.                      {
  490.                         set("\x01",eval("\x01") + 66);
  491.                         break loop0;
  492.                      }
  493.                      if(eval("\x01") == 570)
  494.                      {
  495.                         set("\x01",eval("\x01") + 25);
  496.                         if(┬º┬ºpop())
  497.                         {
  498.                            set("\x01",eval("\x01") + 66);
  499.                         }
  500.                         continue;
  501.                      }
  502.                      if(eval("\x01") == 202)
  503.                      {
  504.                         set("\x01",eval("\x01") + 564);
  505.                         ┬º┬ºpush(true);
  506.                         continue;
  507.                      }
  508.                      if(eval("\x01") == 537)
  509.                      {
  510.                         set("\x01",eval("\x01") - 84);
  511.                         ┬º┬ºpush(true);
  512.                         continue;
  513.                      }
  514.                      if(eval("\x01") == 619)
  515.                      {
  516.                         set("\x01",eval("\x01") + 293);
  517.                         break loop0;
  518.                      }
  519.                      if(eval("\x01") != 129)
  520.                      {
  521.                         if(eval("\x01") == 535)
  522.                         {
  523.                            break loop4;
  524.                         }
  525.                         if(eval("\x01") == 661)
  526.                         {
  527.                            set("\x01",eval("\x01") + 27);
  528.                            ┬º┬ºpush(true);
  529.                         }
  530.                         else
  531.                         {
  532.                            if(eval("\x01") == 406)
  533.                            {
  534.                               set("\x01",eval("\x01") - 281);
  535.                               break loop0;
  536.                            }
  537.                            if(eval("\x01") == 912)
  538.                            {
  539.                               set("\x01",eval("\x01") - 696);
  540.                               ┬º┬ºpush(true);
  541.                            }
  542.                            else
  543.                            {
  544.                               if(eval("\x01") == 166)
  545.                               {
  546.                                  set("\x01",eval("\x01") - 61);
  547.                                  if(!_global.mx)
  548.                                  {
  549.                                     _global.mx = new Object();
  550.                                  }
  551.                                  ┬º┬ºpop();
  552.                                  if(!_global.mx.transitions)
  553.                                  {
  554.                                     _global.mx.transitions = new Object();
  555.                                  }
  556.                                  ┬º┬ºpop();
  557.                                  if(!_global.mx.transitions.BroadcasterMX)
  558.                                  {
  559.                                     _loc2_ = mx.transitions.BroadcasterMX = function()
  560.                                     {
  561.                                     }.prototype;
  562.                                     mx.transitions.BroadcasterMX = function()
  563.                                     {
  564.                                     }.initialize = function(o, dontCreateArray)
  565.                                     {
  566.                                        if(o.broadcastMessage != undefined)
  567.                                        {
  568.                                           delete o.broadcastMessage;
  569.                                        }
  570.                                        o.addListener = mx.transitions.BroadcasterMX.prototype.addListener;
  571.                                        o.removeListener = mx.transitions.BroadcasterMX.prototype.removeListener;
  572.                                        if(!dontCreateArray)
  573.                                        {
  574.                                           o._listeners = new Array();
  575.                                        }
  576.                                     };
  577.                                     _loc2_.addListener = function(o)
  578.                                     {
  579.                                        this.removeListener(o);
  580.                                        if(this.broadcastMessage == undefined)
  581.                                        {
  582.                                           this.broadcastMessage = mx.transitions.BroadcasterMX.prototype.broadcastMessage;
  583.                                        }
  584.                                        return this._listeners.push(o);
  585.                                     };
  586.                                     _loc2_.removeListener = function(o)
  587.                                     {
  588.                                        var _loc2_ = this._listeners;
  589.                                        var _loc3_ = _loc2_.length;
  590.                                        while(true)
  591.                                        {
  592.                                           _loc3_;
  593.                                           if(!_loc3_--)
  594.                                           {
  595.                                              break;
  596.                                           }
  597.                                           if(_loc2_[_loc3_] == o)
  598.                                           {
  599.                                              _loc2_.splice(_loc3_,1);
  600.                                              if(!_loc2_.length)
  601.                                              {
  602.                                                 this.broadcastMessage = undefined;
  603.                                              }
  604.                                              return true;
  605.                                           }
  606.                                        }
  607.                                        return false;
  608.                                     };
  609.                                     _loc2_.broadcastMessage = function()
  610.                                     {
  611.                                        var _loc5_ = String(arguments.shift());
  612.                                        var _loc4_ = this._listeners.concat();
  613.                                        var _loc6_ = _loc4_.length;
  614.                                        var _loc3_ = 0;
  615.                                        while(_loc3_ < _loc6_)
  616.                                        {
  617.                                           _loc4_[_loc3_][_loc5_].apply(_loc4_[_loc3_],arguments);
  618.                                           _loc3_ = _loc3_ + 1;
  619.                                        }
  620.                                     };
  621.                                     mx.transitions.BroadcasterMX = function()
  622.                                     {
  623.                                     }.version = "1.1.0.52";
  624.                                     ┬º┬ºpush(ASSetPropFlags(mx.transitions.BroadcasterMX.prototype,null,1));
  625.                                  }
  626.                                  ┬º┬ºpop();
  627.                                  break loop0;
  628.                               }
  629.                               if(eval("\x01") == 216)
  630.                               {
  631.                                  set("\x01",eval("\x01") + 118);
  632.                                  if(┬º┬ºpop())
  633.                                  {
  634.                                     set("\x01",eval("\x01") - 24);
  635.                                  }
  636.                               }
  637.                               else if(eval("\x01") == 766)
  638.                               {
  639.                                  set("\x01",eval("\x01") - 360);
  640.                                  if(┬º┬ºpop())
  641.                                  {
  642.                                     set("\x01",eval("\x01") - 281);
  643.                                  }
  644.                               }
  645.                               else if(eval("\x01") == 814)
  646.                               {
  647.                                  set("\x01",eval("\x01") - 685);
  648.                                  if(┬º┬ºpop())
  649.                                  {
  650.                                     set("\x01",eval("\x01") + 73);
  651.                                  }
  652.                               }
  653.                               else if(eval("\x01") == 125)
  654.                               {
  655.                                  set("\x01",eval("\x01") + 445);
  656.                                  ┬º┬ºpush(true);
  657.                               }
  658.                               else if(eval("\x01") == 243)
  659.                               {
  660.                                  set("\x01",eval("\x01") - 184);
  661.                                  if(┬º┬ºpop())
  662.                                  {
  663.                                     set("\x01",eval("\x01") + 478);
  664.                                  }
  665.                               }
  666.                               else
  667.                               {
  668.                                  if(eval("\x01") == 59)
  669.                                  {
  670.                                     set("\x01",eval("\x01") + 478);
  671.                                     break loop0;
  672.                                  }
  673.                                  if(eval("\x01") != 453)
  674.                                  {
  675.                                     if(eval("\x01") == 105)
  676.                                     {
  677.                                        set("\x01",eval("\x01") - 105);
  678.                                        break loop0;
  679.                                     }
  680.                                     break loop0;
  681.                                  }
  682.                                  set("\x01",eval("\x01") + 82);
  683.                                  if(┬º┬ºpop())
  684.                                  {
  685.                                     set("\x01",eval("\x01") - 369);
  686.                                  }
  687.                               }
  688.                            }
  689.                         }
  690.                         continue;
  691.                      }
  692.                      set("\x01",eval("\x01") + 73);
  693.                      mx.transitions.easing.Regular = function()
  694.                      {
  695.                      }[┬º┬ºconstant(17)] = mx.transitions.easing.Regular = function()
  696.                      {
  697.                      }.Object;
  698.                   }
  699.                   set("\x01",eval("\x01") - 69);
  700.                   if(!┬º┬ºpop())
  701.                   {
  702.                      continue;
  703.                   }
  704.                   continue loop3;
  705.                }
  706.                set("\x01",eval("\x01") - 369);
  707.                break loop0;
  708.             }
  709.             ┬º┬ºpop()[┬º┬ºpop()] = ┬º┬ºpop();
  710.          }
  711.          set("\x01",eval("\x01") - 913);
  712.          ┬º┬ºpush(true);
  713.       }
  714.       set("\x01",eval("\x01") - 57);
  715.       if(┬º┬ºpop())
  716.       {
  717.          set("\x01",eval("\x01") + 206);
  718.       }
  719.    }
  720.    set("\x01",eval("\x01") + 36);
  721.    ┬º┬ºpush(true);
  722.    continue;
  723.    ┬º┬ºconstant(24)(_global.mx[┬º┬ºconstant(14)],null,1);
  724.    break;
  725. }
  726.